import { defineStore } from 'pinia';
import { ElMessage } from 'element-plus';

/**
 * 文件历史记录存储
 * 用于记录用户访问的文件历史，支持本地和远程文件
 */
export const useFileHistoryStore = defineStore('fileHistory', {
  state: () => ({
    // 历史记录列表，最新访问的排在前面
    history: [],
    
    // 最多保存的历史记录数量
    maxHistorySize: 30,
    
    // 上一次访问的文件，用于快速返回
    lastAccessedFile: null,
    
    // 当前正在查看的文件
    currentFile: null,
  }),
  
  getters: {
    // 获取格式化后的历史记录（按日期分组）
    groupedHistory: (state) => {
      const groups = {};
      
      state.history.forEach(item => {
        const date = new Date(item.timestamp);
        const dateStr = date.toLocaleDateString();
        
        if (!groups[dateStr]) {
          groups[dateStr] = [];
        }
        
        groups[dateStr].push(item);
      });
      
      return Object.entries(groups).map(([date, items]) => ({
        date,
        items
      })).sort((a, b) => new Date(b.date) - new Date(a.date));
    },
    
    // 获取不重复的类别列表
    categories: (state) => {
      const categories = new Set();
      state.history.forEach(item => {
        if (item.category) {
          categories.add(item.category);
        }
      });
      return Array.from(categories);
    },
    
    // 获取最近访问的文件（去重后的前10个）
    recentFiles: (state) => {
      const uniqueFiles = [];
      const fileUrls = new Set();
      
      for (const item of state.history) {
        // 使用URL作为唯一标识
        if (!fileUrls.has(item.url)) {
          fileUrls.add(item.url);
          uniqueFiles.push(item);
          
          // 只保留前10个
          if (uniqueFiles.length >= 10) break;
        }
      }
      
      return uniqueFiles;
    },
  },
  
  actions: {
    /**
     * 添加文件到历史记录
     * @param {Object} file 文件信息对象
     * @param {string} file.name 文件名
     * @param {string} file.url 文件URL
     * @param {string} file.type 文件类型 'document', 'markdown', 'image', 'video'
     * @param {string} file.category 可选的分类
     * @param {string} file.source 来源，'local'=本地文件，'remote'=远程文件
     */
    addToHistory(file) {
      // 确保必要的字段存在
      if (!file || !file.url || !file.name) {
        console.error('添加历史记录失败：文件信息不完整', file);
        return;
      }
      
      // 生成文件ID
      const fileId = this.generateFileId(file);
      
      // 组装记录对象
      const historyItem = {
        ...file,
        id: fileId,
        timestamp: Date.now(),
        accessCount: 1  // 初始访问次数为1
      };
      
      // 检查是否已存在，如果存在则更新时间戳并放到最前面
      const existingIndex = this.history.findIndex(item => item.url === file.url);
      if (existingIndex !== -1) {
        // 更新记录
        historyItem.accessCount = this.history[existingIndex].accessCount + 1;
        
        // 删除旧记录
        this.history.splice(existingIndex, 1);
      }
      
      // 添加到列表前面
      this.history.unshift(historyItem);
      
      // 更新最近访问的文件
      this.lastAccessedFile = historyItem;
      
      // 设置为当前文件
      this.currentFile = historyItem;
      
      // 限制历史记录数量
      if (this.history.length > this.maxHistorySize) {
        this.history = this.history.slice(0, this.maxHistorySize);
      }
    },
    
    /**
     * 根据ID获取文件历史记录
     * @param {string} id 文件ID
     * @returns {Object|null} 文件历史记录或null
     */
    getFileById(id) {
      return this.history.find(item => item.id === id) || null;
    },
    
    /**
     * 根据文件ID加载文件
     * @param {string} id 文件ID
     * @returns {Object|null} 成功加载返回文件对象，失败返回null
     */
    loadFileById(id) {
      const fileRecord = this.getFileById(id);
      
      if (!fileRecord) {
        ElMessage.error(`文件不存在或已被删除`);
        return null;
      }
      
      // 更新访问时间和计数
      fileRecord.timestamp = Date.now();
      fileRecord.accessCount++;
      
      // 更新当前文件和最近文件
      this.lastAccessedFile = fileRecord;
      this.currentFile = fileRecord;
      
      return fileRecord;
    },
    
    /**
     * 更新文件URL（用于处理blob URL失效的情况）
     * @param {string} id 文件ID
     * @param {string} newUrl 新的URL
     */
    updateFileUrl(id, newUrl) {
      const fileRecord = this.getFileById(id);
      
      if (fileRecord && newUrl) {
        fileRecord.url = newUrl;
        
        // 如果是当前文件，也更新当前文件引用
        if (this.currentFile && this.currentFile.id === id) {
          this.currentFile.url = newUrl;
        }
        
        // 如果是最近访问的文件，也更新其引用
        if (this.lastAccessedFile && this.lastAccessedFile.id === id) {
          this.lastAccessedFile.url = newUrl;
        }
      }
    },
    
    /**
     * 从本地存储删除指定ID的文件历史记录
     * @param {string} id 文件ID
     */
    removeFile(id) {
      const index = this.history.findIndex(item => item.id === id);
      
      if (index !== -1) {
        // 如果是当前文件，需要重置当前文件
        if (this.currentFile && this.currentFile.id === id) {
          this.currentFile = null;
        }
        
        // 如果是最近访问文件，也需要重置
        if (this.lastAccessedFile && this.lastAccessedFile.id === id) {
          this.lastAccessedFile = null;
        }
        
        // 移除记录
        this.history.splice(index, 1);
        ElMessage.success('已从历史记录中移除');
      }
    },
    
    /**
     * 清空所有历史记录
     */
    clearHistory() {
      this.history = [];
      this.lastAccessedFile = null;
      this.currentFile = null;
      ElMessage.success('历史记录已清空');
    },
    
    /**
     * 生成文件唯一ID
     * @param {Object} file 文件信息
     * @returns {string} 文件唯一ID
     */
    generateFileId(file) {
      // 对于本地文件，使用URL的哈希值和时间戳组合
      // 对于远程文件，使用URL的哈希值
      
      // 简单的哈希函数
      const hashString = (str) => {
        let hash = 0;
        for (let i = 0; i < str.length; i++) {
          const char = str.charCodeAt(i);
          hash = ((hash << 5) - hash) + char;
          hash = hash & hash; // 转换为32位整数
        }
        return Math.abs(hash).toString(16);
      };
      
      // 远程文件用URL作为ID的一部分
      const urlHash = hashString(file.url);
      
      // 本地文件添加时间戳以确保唯一性
      if (file.source === 'local') {
        const timestamp = Date.now().toString(16);
        return `local-${urlHash}-${timestamp}`;
      }
      
      // 远程文件直接使用URL哈希
      return `remote-${urlHash}`;
    },
    
    /**
     * 构建可分享的文件URL（使用base64编码文件信息）
     * @param {Object} file 文件信息对象
     * @returns {string} 可用于分享的URL
     */
    buildShareableUrl(file) {
      if (!file) return '';
      
      try {
        // 提取需要共享的最小信息集
        const shareInfo = {
          name: file.name,
          url: file.url,
          type: file.type
        };
        
        // 使用base64编码，避免URL过长
        const encoded = btoa(JSON.stringify(shareInfo));
        
        // 生成相对路径，避免绝对路径带来的问题
        return `/file-reader?share=${encoded}`;
      } catch (e) {
        console.error('构建分享链接失败:', e);
        return '';
      }
    }
  },
  
  persist: {
    // 使用localStorage存储
    storage: localStorage,
    
    // 只持久化这些字段
    paths: ['history', 'maxHistorySize', 'lastAccessedFile'],
  },
}); 